home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / c-lang / vbcc.lha / vbcc / parse_expr.c < prev    next >
C/C++ Source or Header  |  1996-05-15  |  23KB  |  749 lines
  1. /*  $VER: vbcc (parse_expr.c) V0.3  */
  2.  
  3. #include "vbc.h"
  4.  
  5. np expression(void)
  6. /*  Komma-Ausdruecke                                        */
  7. {
  8.     np left,right,new;
  9.     left=assignment_expression();
  10.     if(!left->flags) return(0);
  11.     killsp();
  12.     while(*s==','){
  13.         s++;
  14.         killsp();
  15.         right=assignment_expression();
  16.         new=(np)mymalloc(NODES);
  17.         new->left=left;
  18.         new->right=right;
  19.         new->ntyp=0;
  20.         new->flags=KOMMA;
  21.         left=new;
  22.         killsp();
  23.     }
  24.     return(left);
  25. }
  26. np assignment_expression(void)
  27. /*  Zuweisungsausdruecke                                    */
  28. {
  29.     np left,new;int c=0;
  30.     left=conditional_expression();
  31.     killsp();
  32.     if(*s!='='&&*(s+1)!='='&&*(s+2)!='=') return(left);
  33.     if(*s=='=') {c=ASSIGN;s++;} else
  34.     {if(*s=='*'&&*(s+1)=='=') {c=ASSIGNMULT;s+=2;}  else
  35.     {if(*s=='/'&&*(s+1)=='=') {c=ASSIGNDIV;s+=2;}   else
  36.     {if(*s=='%'&&*(s+1)=='=') {c=ASSIGNMOD;s+=2;}   else
  37.     {if(*s=='+'&&*(s+1)=='=') {c=ASSIGNADD;s+=2;}   else
  38.     {if(*s=='-'&&*(s+1)=='=') {c=ASSIGNSUB;s+=2;}   else
  39.     {if(*s=='&'&&*(s+1)=='=') {c=ASSIGNAND;s+=2;}   else
  40.     {if(*s=='^'&&*(s+1)=='=') {c=ASSIGNXOR;s+=2;}   else
  41.     {if(*s=='|'&&*(s+1)=='=') {c=ASSIGNOR;s+=2;}    else
  42.     {if(*s=='<'&&*(s+1)=='<') {c=ASSIGNLSHIFT;s+=3;}else
  43.     {if(*s=='>'&&*(s+1)=='>') {c=ASSIGNRSHIFT;s+=3;}else {return(left);}
  44.     }}}}}}}}}}
  45.     new=(np)mymalloc(NODES);
  46.     new->left=left;
  47.     new->ntyp=0;
  48.     if(c==ASSIGN){
  49.         new->right=assignment_expression();
  50.         new->flags=ASSIGN;
  51.     }else{
  52.         /*  ASSIGNOP(a,b)->ASSIGN(a,OP(a,b))    */
  53.         new->flags=ASSIGNADD;   /* nur zum Merken, dass nur einmal  */
  54.                                 /* ausgewertet werden darf          */
  55.         new->right=(np)mymalloc(NODES);
  56.         new->right->left=left;
  57.         new->right->right=assignment_expression();
  58.         new->right->ntyp=0;
  59.         if(c==ASSIGNMULT) new->right->flags=MULT;
  60.         if(c==ASSIGNDIV) new->right->flags=DIV;
  61.         if(c==ASSIGNMOD) new->right->flags=MOD;
  62.         if(c==ASSIGNADD) new->right->flags=ADD;
  63.         if(c==ASSIGNSUB) new->right->flags=SUB;
  64.         if(c==ASSIGNAND) new->right->flags=AND;
  65.         if(c==ASSIGNXOR) new->right->flags=XOR;
  66.         if(c==ASSIGNOR) new->right->flags=OR;
  67.         if(c==ASSIGNLSHIFT) new->right->flags=LSHIFT;
  68.         if(c==ASSIGNRSHIFT) new->right->flags=RSHIFT;
  69.     }
  70.     return(new);
  71. }
  72. np conditional_expression(void)
  73. /*  Erledigt ? :  momentan noch nicht implementiert         */
  74. {
  75.     np left,new;
  76.     left=logical_or_expression();
  77.     killsp();
  78.     if(*s=='?'){    /*  hier ein while  ?   */
  79.         s++;killsp();
  80.         new=(np)mymalloc(NODES);
  81.         new->flags=COND;
  82.         new->ntyp=0;
  83.         new->left=left;
  84.         new->right=(np)mymalloc(NODES);
  85.         new->right->flags=COLON;
  86.         new->right->ntyp=0;
  87.         new->right->left=expression();
  88.         killsp();
  89.         if(*s==':'){s++;killsp();} else error(70);
  90.         new->right->right=conditional_expression();
  91.         left=new;
  92.         killsp();
  93.     }
  94.     return(left);
  95. }
  96. np logical_or_expression(void)
  97. /*  Erledigt ||                                             */
  98. {
  99.     np left,right,new;
  100.     left=logical_and_expression();
  101.     killsp();
  102.     while(*s=='|'&&*(s+1)=='|'){
  103.         s+=2;
  104.         killsp();
  105.         right=logical_and_expression();
  106.         new=(np)mymalloc(NODES);
  107.         new->left=left;
  108.         new->right=right;
  109.         new->flags=LOR;
  110.         new->ntyp=0;
  111.         left=new;
  112.         killsp();
  113.     }
  114.     return(left);
  115. }
  116. np logical_and_expression(void)
  117. /*  Erledigt &&                                             */
  118. {
  119.     np left,right,new;
  120.     left=inclusive_or_expression();
  121.     killsp();
  122.     while(*s=='&'&&*(s+1)=='&'){
  123.         s+=2;
  124.         killsp();
  125.         right=inclusive_or_expression();
  126.         new=(np)mymalloc(NODES);
  127.         new->left=left;
  128.         new->right=right;
  129.         new->flags=LAND;
  130.         new->ntyp=0;
  131.         left=new;
  132.         killsp();
  133.     }
  134.     return(left);
  135. }
  136. np inclusive_or_expression(void)
  137. /*  Erledigt |                                              */
  138. {
  139.     np left,right,new;
  140.     left=exclusive_or_expression();
  141.     killsp();
  142.     while(*s=='|'&&*(s+1)!='|'&&*(s+1)!='='){
  143.         s++;
  144.         killsp();
  145.         right=exclusive_or_expression();
  146.         new=(np)mymalloc(NODES);
  147.         new->left=left;
  148.         new->right=right;
  149.         new->flags=OR;
  150.         new->ntyp=0;
  151.         left=new;
  152.         killsp();
  153.     }
  154.     return(left);
  155. }
  156. np exclusive_or_expression(void)
  157. /*  Erledigt ^                                              */
  158. {
  159.     np left,right,new;
  160.     left=and_expression();
  161.     killsp();
  162.     while(*s=='^'&&*(s+1)!='='){
  163.         s++;
  164.         killsp();
  165.         right=and_expression();
  166.         new=(np)mymalloc(NODES);
  167.         new->left=left;
  168.         new->right=right;
  169.         new->flags=XOR;
  170.         new->ntyp=0;
  171.         left=new;
  172.         killsp();
  173.     }
  174.     return(left);
  175. }
  176. np and_expression(void)
  177. /*  Erledigt &                                              */
  178. {
  179.     np left,right,new;
  180.     left=equality_expression();
  181.     killsp();
  182.     while(*s=='&'&&*(s+1)!='&'&&*(s+1)!='='){
  183.         s++;
  184.         killsp();
  185.         right=equality_expression();
  186.         new=(np)mymalloc(NODES);
  187.         new->left=left;
  188.         new->right=right;
  189.         new->flags=AND;
  190.         new->ntyp=0;
  191.         left=new;
  192.         killsp();
  193.     }
  194.     return(left);
  195. }
  196. np equality_expression(void)
  197. /*  Erledigt == und !=                                      */
  198. {
  199.     np left,right,new;int c;
  200.     left=relational_expression();
  201.     killsp();
  202.     while((*s=='='||*s=='!')&&*(s+1)=='='){
  203.         if(*s=='!') c=INEQUAL; else c=EQUAL;
  204.         s+=2;
  205.         killsp();
  206.         right=relational_expression();
  207.         new=(np)mymalloc(NODES);
  208.         new->left=left;
  209.         new->right=right;
  210.         new->flags=c;
  211.         new->ntyp=0;
  212.         left=new;
  213.         killsp();
  214.     }
  215.     return(left);
  216. }
  217. np relational_expression(void)
  218. /*  Erledigt <,>,<=,>=                                      */
  219. {
  220.     np left,right,new;int c;
  221.     left=shift_expression();
  222.     killsp();
  223.     while((*s=='<'&&*(s+1)!='<')||(*s=='>'&&*(s+1)!='>')){
  224.         if(*s++=='<'){
  225.             if(*s=='='){s++;c=LESSEQ;}else c=LESS;
  226.         }else{
  227.             if(*s=='='){s++;c=GREATEREQ;}else c=GREATER;
  228.         }
  229.         killsp();
  230.         right=shift_expression();
  231.         new=(np)mymalloc(NODES);
  232.         new->left=left;
  233.         new->right=right;
  234.         new->flags=c;
  235.         new->ntyp=0;
  236.         left=new;
  237.         killsp();
  238.     }
  239.     return(left);
  240. }
  241. np shift_expression(void)
  242. /*  Erledigt <<,>>                                          */
  243. {
  244.     np left,right,new;int c;
  245.     left=additive_expression();
  246.     killsp();
  247.     while((*s=='<'&&*(s+1)=='<'&&*(s+2)!='=')||(*s=='>'&&*(s+1)=='>'&&*(s+2)!='=')){
  248.         if(*s=='<') c=LSHIFT; else c=RSHIFT;
  249.         s+=2;
  250.         killsp();
  251.         right=additive_expression();
  252.         new=(np)mymalloc(NODES);
  253.         new->left=left;
  254.         new->right=right;
  255.         new->flags=c;
  256.         new->ntyp=0;
  257.         left=new;
  258.         killsp();
  259.     }
  260.     return(left);
  261. }
  262. np additive_expression(void)
  263. /*  Erledigt +,-                                            */
  264. {
  265.     np left,right,new;int c;
  266.     left=multiplicative_expression();
  267.     killsp();
  268.     while((*s=='+'||*s=='-')&&*(s+1)!='='){
  269.         if(*s++=='+') c=ADD; else c=SUB;
  270.         killsp();
  271.         right=multiplicative_expression();
  272.         new=(np)mymalloc(NODES);
  273.         new->left=left;
  274.         new->right=right;
  275.         new->flags=c;
  276.         new->ntyp=0;
  277.         left=new;
  278.         killsp();
  279.     }
  280.     return(left);
  281. }
  282. np multiplicative_expression(void)
  283. /*  Erledigt *,/,%                                          */
  284. {
  285.     np left,right,new;int c;
  286.     left=cast_expression();
  287.     killsp();
  288.     while((*s=='*'||*s=='/'||*s=='%')&&*(s+1)!='='){
  289.         if(*s=='*') c=MULT; else {if(*s=='/') c=DIV; else c=MOD;}
  290.         s++;
  291.         killsp();
  292.         right=cast_expression();
  293.         new=(np)mymalloc(NODES);
  294.         new->left=left;
  295.         new->right=right;
  296.         new->flags=c;
  297.         new->ntyp=0;
  298.         left=new;
  299.         killsp();
  300.     }
  301.     return(left);
  302. }
  303. np cast_expression(void)
  304. /*  Erledigt (typ)                                          */
  305. {
  306.     np new;char *imerk,buff[MAXI];
  307.     killsp();
  308.     if(*s!='('||!declaration(1)) return(unary_expression());
  309.     s++;killsp();
  310.     new=(np)mymalloc(NODES);
  311.     new->flags=CAST;
  312.     new->right=0;
  313.     imerk=ident;ident=buff;
  314.     new->ntyp=declarator(declaration_specifiers());
  315.     ident=imerk;
  316.     killsp();
  317.     if(*s!=')') error(59); else s++;
  318.     new->left=cast_expression();
  319.     return(new);
  320. }
  321. np unary_expression(void)
  322. /*  Erledigt !,~,++,--,+,-,*,&,sizeof                       */
  323. {
  324.     np new;char *merk=s,buff[MAXI];int done=0;
  325.     killsp();
  326.     if((*s!='s'&&*s!='+'&&*s!='-'&&*s!='&'&&*s!='*'&&*s!='~'&&*s!='!')||*(s+1)=='=') return(postfix_expression());
  327.     if(*s=='s'){
  328.         merk=s;cpbez(buff);s=merk;
  329.         if(strcmp("sizeof",buff)) return(postfix_expression());
  330.         else{
  331.             s+=6;killsp();
  332.             new=(np)mymalloc(NODES);
  333.             new->flags=CEXPR;
  334.             new->ntyp=(struct Typ *)mymalloc(TYPS);
  335.             new->ntyp->flags=UNSIGNED|LONG;
  336.             new->ntyp->next=0;
  337.             new->right=0;
  338.             new->left=0;
  339.             if(*s=='('&&declaration(1)){
  340.                 struct Typ *t;
  341.                 s++;killsp();
  342.                 merk=ident;ident=buff;
  343.                 t=declarator(declaration_specifiers());
  344.                 if(type_uncomplete(t)) error(176);
  345.                 ident=merk;
  346.                 new->val.vulong=zl2zul(l2zl((long)szof(t)));
  347.                 freetyp(t);
  348.                 killsp();
  349.                 if(*s!=')') error(59); else s++;
  350.             }else{
  351.                 np tree;
  352.                 killsp();
  353.                 tree=unary_expression();
  354.                 if(!tree||!type_expression(tree)){
  355.                     new->val.vulong=zl2zul(l2zl(0L));
  356.                     error(73);
  357.                 }else{
  358.                     if(type_uncomplete(tree->ntyp)) error(176);
  359.                     new->val.vulong=zl2zul(l2zl((long)szof(tree->ntyp)));
  360.                 }
  361.                 if(tree) free_expression(tree);killsp();
  362.             }
  363.             return(new);
  364.         }
  365.     }
  366.     new=(np)mymalloc(NODES);
  367.     new->right=0;
  368.     new->ntyp=0;
  369.     if(*s=='+'&&!done)
  370.         if(*(s+1)=='+'){
  371.             s+=2;done=1;
  372.             new->left=unary_expression();
  373.             new->flags=PREINC;
  374.         }else{
  375.             s++;free(new);
  376.             return(cast_expression());
  377.         }
  378.     if(*s=='-'&&!done){
  379.         done=1;
  380.         if(*(s+1)=='-'){
  381.             s+=2;
  382.             new->left=unary_expression();
  383.             new->flags=PREDEC;
  384.         }else{
  385.             s++;
  386.             new->left=cast_expression();
  387.             new->flags=MINUS;
  388.         }
  389.     }
  390.     if(*s=='&'&&!done){
  391.         s++;done=1;
  392.         new->left=cast_expression();
  393.         new->flags=ADDRESS;
  394.     }
  395.     if(*s=='*'&&!done){
  396.         s++;done=1;
  397.         new->left=cast_expression();
  398.         new->flags=CONTENT;
  399.     }
  400.     if(*s=='~'&&!done){
  401.         s++;done=1;
  402.         new->left=cast_expression();
  403.         new->flags=KOMPLEMENT;
  404.     }
  405.     if(*s=='!'&&!done){
  406.         s++;done=1;
  407.         new->left=cast_expression();
  408.         new->flags=NEGATION;
  409.     }
  410.     new->right=0;
  411.     new->ntyp=0;
  412.     return(new);
  413. }
  414. np postfix_expression(void)
  415. /*  Erledigt [],(),.,->,++,--                                   */
  416. {
  417.     np new,left;int done;
  418.     left=primary_expression();
  419.     killsp();
  420.     while(*s=='['||*s=='('||*s=='.'||(*s=='-'&&((*(s+1)=='-')||(*(s+1)=='>')))
  421.           ||(*s=='+'&&*(s+1)=='+')){
  422.         done=0;
  423.         new=(np)mymalloc(NODES);
  424.         new->ntyp=0;
  425.         new->right=0;
  426.         new->left=left;
  427.         if(*s=='-'){
  428.             s++;done=1;
  429.             if(*s=='-'){
  430.                 s++;
  431.                 new->flags=POSTDEC;
  432.             }else{
  433.                 s++; killsp();
  434.                 new->flags=DSTRUCT;
  435.                 new->right=identifier_expression();
  436.                 new->right->flags=MEMBER;
  437.                 new->left=(np)mymalloc(NODES);
  438.                 new->left->ntyp=0;
  439.                 new->left->left=left;
  440.                 new->left->right=0;
  441.                 new->left->flags=CONTENT;
  442.             }
  443.         }
  444.         if(*s=='['&&!done){
  445.             s++; killsp();done=1;
  446.             new->flags=CONTENT;
  447.             new->left=(np)mymalloc(NODES);
  448.             new->left->flags=ADD;
  449.             new->left->ntyp=0;
  450.             new->left->left=left;
  451.             new->left->right=expression();
  452.             killsp();
  453.             if(*s!=']') error(62); else s++;
  454.         }
  455.         if(*s=='+'&&!done){
  456.             s+=2;done=1;
  457.             new->flags=POSTINC;
  458.         }
  459.         if(*s=='.'&&!done){
  460.             s++;killsp();done=1;
  461.             new->right=identifier_expression();
  462.             new->flags=DSTRUCT;
  463.             new->right->flags=MEMBER;
  464.         }
  465.         if(*s=='('&&!done){
  466.             struct argument_list *al,*first_alist=0,*last_alist=0;np n;
  467.             s++;killsp();done=1;
  468.             new->flags=CALL;
  469.             new->right=0;
  470.             while(*s!=')'){
  471.                 n=assignment_expression();
  472.                 al=(struct argument_list *)mymalloc(sizeof(struct argument_list));
  473.                 al->arg=n;al->next=0;
  474.                 if(last_alist){
  475.                     last_alist->next=al;
  476.                     last_alist=al;
  477.                 }else{
  478.                     last_alist=first_alist=al;
  479.                 }
  480.                 killsp();
  481.                 if(*s==',') {s++;killsp();} /* hier noch strenger */
  482.             }
  483.             new->alist=first_alist;
  484.             if(*s!=')') error(59); else s++;
  485.         }
  486.         left=new;
  487.         killsp();
  488.     }
  489.     return(left);
  490. }
  491. np primary_expression(void)
  492. /*  Hier fehlt noch allerhand                               */
  493. {
  494.     np new;
  495.     if((*s>='0'&&*s<='9')||*s=='.') return(constant_expression());
  496.     if(*s=='\"'||*s=='\''||(*s=='L'&&(*(s+1)=='\''||*(s+1)=='\"'))) return(string_expression());
  497.     if(*s=='('){
  498.         s++;killsp();
  499.         new=expression();
  500.         killsp();
  501.         if(*s!=')') error(59); else s++;
  502.         return(new);
  503.     }
  504.     return(identifier_expression());
  505. }
  506. np string_expression(void)
  507. /*  Gibt Zeiger auf string oder Zeichenkonstante zurueck    */
  508. {
  509.     np new; char f,string[MAXINPUT],*p;int flag,val;zlong zl;
  510.     if(*s=='L') s++;    /*  Noch keine erweiterten Zeichen  */
  511.     p=string;f=*s++;
  512.     while(1){
  513.         while(*s!=f&&p<&string[MAXINPUT-1]){
  514.             if(*s=='\\'){
  515.                 s++;
  516.                 if(*s=='\\'){*p++='\\';s++;continue;}
  517.                 if(*s=='n'){*p++='\n';s++;continue;}
  518.                 if(*s=='t'){*p++='\t';s++;continue;}
  519.                 if(*s=='r'){*p++='\r';s++;continue;}
  520.                 if(*s=='v'){*p++='\v';s++;continue;}
  521.                 if(*s=='b'){*p++='\b';s++;continue;}
  522.                 if(*s=='f'){*p++='\f';s++;continue;}
  523.                 if(*s=='a'){*p++='\a';s++;continue;}
  524.                 if(*s=='\?'){*p++='\?';s++;continue;}
  525.                 if(*s=='\''){*p++='\'';s++;continue;}
  526.                 if(*s=='\"'){*p++='\"';s++;continue;}
  527.                 flag=val=0;
  528.                 while(*s>='0'&&*s<='7'&&flag<3){
  529.                     val=val*8+*s-'0';
  530.                     s++;flag++;
  531.                 }
  532.                 if(flag){*p++=val;continue;}
  533.                 if(*s=='x'){
  534.                     s++;val=0;
  535.                     while((*s>='0'&&*s<='9')||(*s>='a'&&*s<='f')||(*s>='A'&&*s<='F')){
  536.                         val=val*16;
  537.                         if(*s>='0'&&*s<='9') val+=*s-'0';
  538.                         if(*s>='a'&&*s<='f') val+=*s-'a'+10;
  539.                         if(*s>='A'&&*s<='F') val+=*s-'A'+10;
  540.                         s++;
  541.                     }
  542.                     *p++=val;continue;
  543.                 }
  544.                 error(71);
  545.             }
  546.             *p++=*s++;
  547.         }
  548.         if(*s!=f) error(74); else s++;
  549.         killsp();
  550.         if(f!='\"'||*s!=f) break; else s++;
  551.     }
  552.     *p=0;
  553.     new=(np)mymalloc(NODES);
  554.     new->ntyp=(struct Typ *)mymalloc(TYPS);
  555.     if(f=='\"'){
  556.         struct const_list *cl,**prev;int i;
  557.         new->ntyp->flags=ARRAY;
  558.         new->ntyp->size=p-string+1;
  559.         new->ntyp->next=(struct Typ *)mymalloc(TYPS);
  560.         new->ntyp->next->flags=STRINGCONST|CHAR;
  561.         new->ntyp->next->next=0;
  562.         new->flags=STRING;
  563.         prev=(struct const_list **)&new->identifier;
  564.         for(i=0;i<p-string+1;i++){
  565.             cl=(struct const_list *)mymalloc(CLS);
  566.             cl->next=0;
  567.             cl->tree=0;
  568.             cl->other=(struct const_list *)mymalloc(CLS);
  569.             cl->other->next=cl->other->other=0;
  570.             cl->other->tree=0;
  571.             cl->other->val.vchar=zl2zc(l2zl((long)string[i]));
  572.             *prev=cl;
  573.             prev=&cl->next;
  574.         }
  575. /*        new->identifier=add_identifier(string,p-string);*/
  576.         new->val.vlong=l2zl(0L);
  577.     }else{
  578.         new->ntyp->flags=CONST|INT;
  579.         new->ntyp->next=0;
  580.         new->flags=CEXPR;
  581.         zl=l2zl(0L);
  582.         p--;
  583.         if(p>string) error(72);
  584.         while(p>=string){
  585.             /*  zl=zl<<CHAR_BIT+*p  */
  586.             zl=zllshift(zl,l2zl((long)CHAR_BIT));
  587.             zl=zladd(zl,l2zl((long)*p));
  588.             new->val.vint=zl2zi(zl);
  589.             p--;
  590.         }
  591.     }
  592.     new->left=new->right=0;
  593.     return(new);
  594. }
  595. np constant_expression(void)
  596. /*  Gibt Zeiger auf erzeugt Struktur fuer Konstante zurueck */
  597. /*  Es werden die Werte aus <limits.h> benutzt.             */
  598. {
  599.     np new; zdouble db;
  600.     zulong value,zbase,digit;unsigned long base=10,t;char *merk;
  601.     merk=s;
  602.     value=ul2zul(0L);
  603.     new=(np)mymalloc(NODES);
  604.     new->ntyp=(struct Typ *)mymalloc(TYPS);
  605.     new->ntyp->flags=0;
  606.     new->ntyp->next=0;
  607.     new->flags=CEXPR;
  608.     new->left=new->right=0;
  609.     new->sidefx=0;
  610.     if(*s=='0'){
  611.         s++;
  612.         if(*s=='x'||*s=='X'){s++;base=16;} else base=8;
  613.     }
  614.     zbase=ul2zul(base);
  615.     if(*s>='0'&&*s<='9') t=*s-'0'; else{
  616.     if(*s>='a'&&*s<='f') t=*s-'a'+10; else{
  617.     if(*s>='A'&&*s<='F') t=*s-'A'+10; else{t=20;}}}
  618.     while(t<base){
  619.         digit=ul2zul(t);
  620.         value=zuladd(zulmult(value,zbase),digit);
  621.         s++;
  622.         if(*s>='0'&&*s<='9') t=*s-'0'; else{
  623.         if(*s>='a'&&*s<='f') t=*s-'a'+10; else{
  624.         if(*s>='A'&&*s<='F') t=*s-'A'+10; else{t=20;}}}
  625.     }
  626.     while(*s=='u'||*s=='U'||*s=='l'||*s=='L'){
  627.         if(*s=='u'||*s=='U'){
  628.             if(zulleq(value,UINT_MAX)) new->ntyp->flags=UNSIGNED|INT;
  629.              else               new->ntyp->flags=UNSIGNED|LONG;
  630.         }else{
  631.             if(zulleq(value,LONG_MAX)) new->ntyp->flags=LONG;
  632.              else               new->ntyp->flags=UNSIGNED|LONG;
  633.         }
  634.         s++;
  635.     }
  636.     if(new->ntyp->flags==0){
  637.         if(base==10){
  638.             if(zulleq(value,INT_MAX)) new->ntyp->flags=INT; else{
  639.             if(zulleq(value,LONG_MAX)) new->ntyp->flags=LONG; else
  640.                                 new->ntyp->flags=UNSIGNED|LONG;}
  641.         }else{
  642.             if(zulleq(value,INT_MAX)) new->ntyp->flags=INT; else{
  643.             if(zulleq(value,UINT_MAX))new->ntyp->flags=UNSIGNED|INT; else{
  644.             if(zulleq(value,LONG_MAX))new->ntyp->flags=LONG; else
  645.                                new->ntyp->flags=UNSIGNED|LONG;}}
  646.         }
  647.     }
  648.     if(*s=='.'||*s=='e'||*s=='E'){
  649.     /*  Fliesskommakonstante, ignoriert vorher berechneten Wert, falls er   */
  650.     /*  nicht dezimal und nicht 0 war (da er dann oktal war)                */
  651.         if(*merk=='0'&&!zuleq(value)){
  652.             value=ul2zul(0UL);zbase=ul2zul(10UL);
  653.             while(*merk>='0'&&*merk<='9'){
  654.                 digit=ul2zul((unsigned long)(*merk-'0'));
  655.                 value=zuladd(zulmult(value,zbase),digit);
  656.                 merk++;
  657.             }
  658.             if(merk!=s) error(75);
  659.         }
  660.         db=zul2zd(value);
  661.         if(*s=='.'){
  662.         /*  Teil hinter Kommastellen    */
  663.             zdouble zquot,zbased,digit;
  664.             s++;
  665.             zbased=d2zd(10);zquot=d2zd(0.1);
  666.             while(*s>='0'&&*s<='9'){
  667.                 digit=d2zd((double)(*s-'0'));
  668.                 db=zdadd(db,zdmult(digit,zquot));
  669.                 zquot=zddiv(zquot,zbased);
  670.                 s++;
  671.             }
  672.  
  673.         }
  674.         if(*s=='e'||*s=='E'){
  675.         /*  Exponentialdarstellung  */
  676.             int exp,vorz,i;zdouble zbased;
  677.             zbased=d2zd((double)10);
  678.             s++;
  679.             if(*s=='-'){
  680.                 s++;vorz=-1;
  681.             }else{
  682.                 vorz=1;if(*s=='+') s++;
  683.             }
  684.             exp=0;
  685.             while(*s>='0'&&*s<='9') exp=exp*10+*s++-'0';
  686.             for(i=0;i<exp;i++){
  687.                 if(vorz>0) db=zdmult(db,zbased);
  688.                     else   db=zddiv(db,zbased);
  689.             }
  690.         }
  691.         new->ntyp->flags=DOUBLE;
  692.         if(*s=='f'||*s=='F'){
  693.             new->ntyp->flags=FLOAT;s++;
  694.         }else{
  695.         /*  long double werden nicht unterstuetzt und sind==double :-(  */
  696.             if(*s=='l'||*s=='L') s++;
  697.         }
  698.     }
  699.     if(new->ntyp->flags==FLOAT) new->val.vfloat=zd2zf(db);
  700.     if(new->ntyp->flags==DOUBLE) new->val.vdouble=db;
  701.     if(new->ntyp->flags==INT) new->val.vint=zl2zi(zul2zl(value));
  702.     if(new->ntyp->flags==(UNSIGNED|INT)) new->val.vuint=zul2zui(value);
  703.     if(new->ntyp->flags==LONG) new->val.vlong=zul2zl(value);
  704.     if(new->ntyp->flags==(UNSIGNED|LONG)) new->val.vulong=value;
  705.     return(new);
  706. }
  707. np identifier_expression(void)
  708. /*  Erzeugt Identifier mit Knoten                           */
  709. {
  710.     np new;char buff[MAXI];
  711.     killsp();cpbez(buff);
  712.     new=(np)mymalloc(NODES);
  713.     new->flags=IDENTIFIER;
  714.     new->left=new->right=0;
  715.     new->identifier=add_identifier(buff,strlen(buff));
  716.     new->ntyp=0;
  717.     new->sidefx=0;
  718.     new->val.vlong=l2zl(0L);
  719.     if(new->identifier==empty) {error(76);new->flags=0;}
  720.     return(new);
  721. }
  722. void free_alist(struct argument_list *p)
  723. /*  Gibt argument_list inkl. expressions frei                   */
  724. {
  725.     struct argument_list *merk;
  726.     while(p){
  727.         merk=p->next;
  728.         if(p->arg) free_expression(p->arg);
  729.         free(p);
  730.         p=merk;
  731.     }
  732. }
  733. void free_expression(np p)
  734. /*  Gibt expression mit allen Typen etc. frei                   */
  735. {
  736.     if(!p) return;
  737.     if(p->flags==ASSIGNADD){
  738.         if(!p->right){ierror(0);return;}
  739.         if(p->right->left==p->left)  p->left=0;
  740.         if(p->right->right==p->left) p->left=0;
  741.     }
  742.     if(p->flags==CALL&&p->alist) free_alist(p->alist);
  743.     if(p->ntyp) freetyp(p->ntyp);
  744.     if(p->left) free_expression(p->left);
  745.     if(p->right) free_expression(p->right);
  746.     free(p);
  747. }
  748.  
  749.